Handling different service versions in a server

ABSTRACT

This invention relates to handling of different service versions in a server that is connected to a communication network. The invention comprises means to load a desired version, two tables and additional data for handling different service versions. The first table contains service key and version information, and serialized service objects. The second table contains names of classes, version information and class files. The additional data is needed for loading the right class from among classes, with the same name, and mapping the right service object version to the right versions of classes.

FIELD OF THE INVENTION

This invention relates to handling of different service versions in aserver that is connected to a communication network. The server offersservices for users. The invention can be used, among other applications,in the provision of telecommunication services

BACKGROUND OF THE INVENTION

At present, a hierarchy (called a multitier architecture) for deliveringservices to clients comprises three basic elements: client browser,application server and database. See FIG. 1. For example, when asubscriber wants to use a special service, he can download it throughthe browser (1). The subscriber defines the service in the browser,which sends the service order to the application server (2). Theapplication server executes the service and sends the desired responseto the client server. The application server may use the database (3)(or databases) if the application server needs specific data or programsfor executing the service.

FIG. 2 shows an example of how a mobile user (5) utilizes services ofthe application server (2). An intelligent network (4) provides theservices to the user. The network can provide the same service toseveral users (millions of users) at a time. In this example, it isworth of noticing that the intelligent network is more in the role ofthe user of the services than just a plain transmission network.

Application servers (a server is a device, connected to a network, thatprovides services, i.e. applications, to network users by managingshared resources) on a network run thousands of different services forup to millions of simultaneous users. Usually the services contain oneor more binary format files (executable codes, data). The common way isto use a programming language, such as Java, to form services andvirtual machine environment, such as Java virtual machine, to executeservices. In the Java environment binary format files are mostly calledclasses. A class file contains Java virtual machine instructions and asymbol table, as well as other ancillary information. Two or moreservices can share the same classes.

For understanding the description of the invention, basic structures ofthe Java language should be kept in mind. Java is an object-orientedprogramming language. An object is a software component that usuallycontains executive codes and data. In an object-oriented language actualobjects are not defined, but classes of objects are defined. A class isa template for multiple objects with similar features. It can be saidthat a class describes all common features for all objects in the class.So, a single object is a concrete representation of the class, in otherwords an instance.

Methods are functions, i.e. executable codes that operate on a class oran object. A stream is a path of communication between the source Ofsome information and its destination. Java contains several inputstreamand outputstream classes for defining different streams. Serializing isa feature in Java environment that makes it possible to save a state ofan instance of the class (the concrete representation of a class) in theform of a byte-line. Serialized instances can be deserialized making itpossible to use the saved class representation later. To sum up, a Javaapplication comprises classes, which refer to objects. One of theclasses is the “root” class, which contains basic methods of theapplication and makes it possible to get the other classes that belongto the application.

Classes may change occasionally. Old classes may contain errors that aredesired to be eliminated, or it may be desired to have a more efficientclass version. Different service providers may also use same names fordifferent classes. Due to these items, a service may use a differentclass version than it has used normally. Let's take an example where asubscriber is using an old browser to get a special service. However,the service has updated for a new browser after the latest subscriber'suse of service, and due to this the service do not work properly.Another example can be when a service consists of several classes.Updating one or more classes may cause incompatibilities among theclasses in the service. Tedious testing is required for checkingcompatibility matters between old and new class versions.

In Microsoft WindoWS™ environment and also in Unix environment there aredynamic link libraries, DLLs, comprising reusable software components.The software components needed by applications are distributed as DLLs.Th ere can b e a multitude of applications that use same reusablesoftware components. In other words, a dynamic link library (DLL) is acollection of small programs, which can be called when needed by theexecutable program or process that is running. For example, the DLL letsthe executable program to communicate with a specific device, such as aprinter, or it may contain source code to do particular functions.

Furthermore, for example, a program (exe) needs to stem a certain wordwithin a character string it can call the DLL file that contains thefunction with parameters and a call function. The DLL will tell theexecutable program the stem form of the word. This allows the executableprogram to be small in size and it does not need to rewrite the functionthat has already been written. This allows that any program, needing tostem a word, does not have to write all the source code and to savespace on secondary storage as well. DLLs in this fashion are also knownas shared files.

The advantage of DLL files is that (because they do not get loaded intorandom access memory (RAM) together with the main program) space issaved in RAM. Only when and if a DLL file is called, it is loaded. Forexample, when you are editing a Microsoft Word™ document, the printerdriver DLL file does not need to be loaded into RAM. If you decide toprint the document, then the printer DLL file is loaded and run.

All in all a DLL is an executable file that cannot be run on it's own,it can only be run from inside an executable file.

When an application is executed it is necessary that the componentsmatch the application. For example, in Microsoft Windows™ environmentthe matching of components and the application is achieved so that whenan application is compiled or linked, it recalls the version numbers ofthe DLLs present in the programming environment. This means that theapplication is labelled with the version numbers of the DLLs used. Whenan application is started, it checks the version numbers of the DLLspresent in its current execution environment, that is, such as thecurrent computer. If the version numbers present are older than thestamps or labels on the application, the application refuses to run.

In the Microsoft Windows™ environment there can be different versions ofcomponents. This is achieved by having path definitions that havedifferent precedencies. The alternative DLLs are stored in differentfolders. It is usual in many environments that the DLLs and theapplications can be installed separately.

It may happen that an application must be run using the componentsagainst which it has originally been written and tested. This means, forexample, that their versions do not match.

If an application starts to use new versions of installed DLLs problemsmay occur. This is due to the fact that in the application there can befaults that are corrected accidentally by the old DLLs. Alternatively,the internal logic of a DLL may have change in a way that is notreflected by having new parameters in the interface definition etc.

The problem is worse in service hotel environments, such as networkservers, where the applications are developed elsewhere and installedlater on to a different execution environment, for example, on adifferent server. Basically, each possible combination of an applicationversion and its components versions should have to be checked.

In Java, it is possible to serialize and deserialize objects, whichmeans that an object can be transferred to another virtual machine, orthe object can later on be reinstantiated having the same state as bythe time it was serialized. The state comprises the attribute values ofthe object attributes and any other objects instantiated within theobject prior to serialization.

Also objects referred to within the object are serialized andreinstantiated along the object. The Java property of objectserialization and reinstantiation can be used for many purposes, forinstance, user interface objects can be instantiated with predefinedcomponents such as scrollers, buttons and menus—these are represented aslinked subordinate objects that are as well serialized along theobject—and certain initial data values.

In Java there is also version control, which sees that deserializedobjects are of the same class version as in their original environment.The version control is achieved so that with each serialized object isassociated a SUID (Stream Unique Identifier), forming a serial versionunique identifier that is stored in addition to the class name andobject attribute values in the serialized form. The SUID is a hash valuecomputed on the text format class interface definition comprising methodsignatures and serialized attributes. In the receiving environment thereis a compiled class having the same interface definition. The Javadeserializer computes a similar hash value of the target class in thereceiving environment. Thereafter, the deserializer checks that the hashvalues agree.

In Java it is possible to use class loaders, i.e. it is possible to loadcompiled bytecode comprising a class into the virtual machine. A classcan be loaded, for instance, from local filesystem i.e. a specifieddirectory accessed by the computer running the virtual machine. A classcan as well be loaded over the Internet using HTTP (Hypertext TransferProtocol) or FTP (File Transfer Protocol). In many applications it isalso useful to store classes into databases. In a virtual machine therecan be several class loaders: at least the primordial class loader, thatis, the default class loader, and possibly some customized classloaders. The customized class loaders can be used to affect the processof class loading. The benefit of Java class loader mechanism is that theuse of customized class loaders is not visible for the programmer whenclasses to be loaded using the customized loader are instantiated. Theclasses are just instantiated normally like any new class instances. Byhaving several class loaders, it is possible to have at least twoversions of a class having the same name. These two versions of theclass can happily co-exist within the virtual machine. Each objectmemorizes its class loader.

The situation where in a virtual machine there exists two objects withinsame class names but different class bytecode versions cannot beachieved with just the primodial class loader. The classes have to beloaded using alternative class loaders.

Now the serialization and deserialization process is considered from theservice execution environment point of view. A service executionenvironment is executing application programs that determine thebehaviour of a service for an end-user. The service can be, forinstance, a subscriber service within an intelligent telecommunicationsnetwork or it can be a WWW (World Wide Web) service executing processwithin a WWW-server environment.

A service can be seen as an instance of a highest-level object. Theclass code for the object and the objects attribute values determine thebehaviour of the service. Of course, the behaviour can be achieved usingsubordinate objects which are referenced from the highest level object,by calling methods on these objects. References to these objects can beobtained via data read from databases or by just instantiating newobjects. The instantiated subordinate objects are deserialized alongwith the service object itself. As explained before, in large serviceexecution environments there can exist several versions of varioussubordinate object classes commonly used by different services. When aninstance of a service is created, for instance, for a subscriberinvoking the service, an initial object instance is formed for theservice instance. It is beneficial to instantiate the service instanceby deserializing an object instance so that certain initial attributevalues can be obtained without unnecessary value initializations andobject instantiation. When deserializing the object instance for theservice instance, it is necessary to serialize correct versions of thesubordinate objects referenced by the service.

This could be done by using object SUIDs to find the correct classes.However, this solution has certain drawbacks such as that the solutiononly applies for the classes for which there are data references. Thesolution does not apply to classes that are referenced on code level.

SUMMARY OF THE INVENTION

The invention offers a way to avoid these drawbacks of presenttechnology. The goal of the invention is achieved in a way described inthe claims.

The invention is not restricted to the Java environment, but it can alsobe used in other object-oriented environment. Due to this, it is naturalto use Java terms in this text.

In the following description the term service refers to a versionedapplication i.e. an application of which several versions exist. Aservice is an application that is implemented and identified as aservice object or a cluster of mutually referring objects. Accordingly,a service is invoked by calling a method on the service object. Severalversions of the same application can co-exist simultaneously. Eachapplication version can be implemented as a separate service,accordingly as a separate service object.

In the following description the term service repository is a databasecontaining service objects and their associated classes. A serviceloader retrieves service objects from the service repository based on aservice key. The service loader deserializes or otherwise reconstructsthe service objects stored persistently in the service repository.

The invention comprises means to load a desired version, a servicerepository consisting of two tables and additional data for handlingdifferent service versions. The first table contains service key andversion information, and serialized service objects (an object thatcontains the all state information of a service). The second tablecontains names of classes, version information and class files (classesin services). The additional data is needed for loading the right classfrom among classes, with the same name, and mapping the right serviceobject version to the right versions of classes.

When requesting a service, the service objects are loaded by the serviceloader from the first table by using the service key provided in therequest. Through the service key, the version information and theservice objects are reached. Next, the version information is used forforming a version specific class loader. The class loader loads thedesired classes included to the service from the second table for theservice objects. The class loader uses the version information of theservice objects from the first table and the version information of theclasses from the second table for mapping the right versions together.The class loader may use other additional data for helping mapping aswell.

BRIEF DESCRIPTION OF THE DRAWINGS

In the following the preferred embodiments of the invention aredescribed in more detail with reference to FIGS. 1-7 in the attacheddrawings wherein

FIG. 1 illustrates an example of the service hierarchy at presentcommunication networks,

FIG. 2 illustrates an example of the service hierarchy in an intelligentnetwork environment,

FIG. 3 illustrates an example of how the elements of the invention canbe situated at present multitier architecture,

FIG. 4 illustrates an example of searching right components for aservice application,

FIG. 5 illustrates an example of two tables according to the invention,

FIG. 6 shows an example of how an application is based on a main serviceprogram and service components.

FIG. 7 shows an example of a flow chart describing the method accordingto the invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

As mentioned, the invention aims to solve problems associated with priorart. A goal is to ensure that the most up to date classes are installedwith a service. This aims to guarantee that none of classes is olderthan the latest supposed tested version, i.e. older-than-tested. Thus itcan be said that a goal of the invention is that none of the classes isnewer-than-tested (a really tested service).

FIG. 3 illustrates an example of how the elements of the inventions canbe situated at present multitier architectures. The both tables are in arelation database (6), preferably in an application server (2). Thetables can also be in an external database (3). The application serveralso contains means (7), called service and class loaders, to loaddesired service components from the database for the use of theapplication server. When a subscriber wants to use a specific service,he requests it from the application server. The service and classloaders in the application server take care of loading the desiredservice objects and classes.

After the receiving of the request to execute a service, the service andthe class loaders can optionally check first if the service object andclasses are in their respective caches. If they are and there is noparticular reason to load classes or objects again, the service is readyto run immediately. If some classes or objects are missing or there is areason for reloading classes or objects, for example a procedure forensuring right versions, the service and class loaders load the relevantclasses and objects from the database. However, normally the serviceloader and the class loader load the service objects and classes fromthe database.

FIG. 4 shows an example of searching the right service object andclasses for the execution of a service. The service loader (8) and anexecutive program knows only the service key (SP Z) of the desiredapplication, i.e. the name of the service object. After searching, basedon the service key, the service loader loads (C1) the record of SP Zfrom Table A. After this, the executive program also knows the versionand the classes (information of the classes in the object field) neededbased on the record of SP Z.

Now, a version specific class loader (9) is created for searching theright classes in Table B. The new loader is preferably created accordingto the version information of the loaded service objects. Aftersearching this versioned class loader downloads (C2) the classes, inthis case SC Y and SC U, from Table B. In other words, the versionedclass loader makes it possible to map the right classes to the rightservice object. It is worth noticing that each service application mayhave its own class loader for searching classes. Furthermore, it shouldbe noticed that the versioned class loader can alternatively exist (insome predetermined cases) in which case it does not need to be created.

FIG. 5 shows an example of how to arrange data records according to theinvention. As mentioned before, a service comprises a service object andone or more classes. Table A (a first data group) contains records ofservice objects. A record comprises the key of the service object,version information field and object field. Correspondingly, Table B (asecond data group) contains records (name, version and data fields) ofclasses. In table A, The object field contains serialized stateinformation of the object, and in Table B the data field of a classcontains executable codes, some state information and other data in theform of class file. Preferably, the tables are in a relation database.

A desired service is called in using it's service key in Table A. Bylooking the object version information field, it's possible to searchright classes in Table B. Let's figure a service whose key is Service 1and class Comp1. As can be noticed in FIG. 5, the version information ofthe service can, for example, be a date when the service was created.The object field of Service 1 also contains name information of classesthat belong to the service. The right version of Comp 1 is the versionthat has been created at the same time or before than Service 1. In thiscase, Comp 1 and Service 1 were created at the same time, and thus Comp1 is the acceptable version.

Another example is when a class is older than a service object. This isthe case when Service 2 contains Comp 2. Comp 2 was created beforeService 2 was created or updated. A third example is when Service Ncontains Comp N (the lowest row). In this case, Comp N is newer thanService N, and thus not acceptable to use in Service N. There has to beanother data record in Table B with the name Comp N (the second lowestrow) whose version is equal or older than the version of Service N.

It may also happen that two services have a same key which is thesituation concerning Service 3 keys in Table A. However, in thisexample, Service 3's use different classes—Service 3, whose versioninformation is 05.05.00 uses Comp 3, and Service 3, whose versioninformation is 05.12.99 uses Comp N with the version information04.12.99.

In the above examples the mapping between Table A and Table B uses thedate information in the version fields, but this is not the onlysolution. Actually, the version information in both tables can be otherthan a date, such as some kind of version stamp (compare version namesof common software in market). Anyway, the date information isconvenient to use.

On the other hand, the mapping can be implemented, for example, by usingan additional table containing all version information of the serviceobjects and classes from the tables A and B. Additional data or aheuristic algorithm may be needed for mapping, especially when thereexist several service objects or classes with the same name.

As mentioned, Java offers a way for handling different class versions,namely SUIDs (stream unique identifier). The SUID is as an abstract (acode) from the interface of a class. When a serialized class isdeserialized the SUIDs can be used for verification of the serializedand deserialized class. If the SUID of the serialized class is differentthan the SUID of the deserialized class, it can be notified that theoriginal serialized class version is different than the new deserializedclass version.

However, there are some problems when using SUID for handling differentversions. First, SUID checks only the changes in the interface, butthere can be changes in other parts of the class. Interfaces changerarely and changes between different class versions are mostly done inother parts of classes. Secondly, only classes of serialized objectswould be versioned. Classes that are referred only by code will not beversioned.

It should be noted that the examples above are simplified cases forhelping the description of the invention. Other ways exist forconstructing an arrangement according to the invention. For example, adata storage that contains the object and class groups (tables) can beseen as a service repository. In the service repository, there areentries, each entry storing an object or a class. An entry is a set oflogically associated pieces of information. In the context of thisinvention an entry comprises the information necessary to store anobject or a class. On abstract level an entry comprises a set ofattributes each of which may have a value associated with it.

An entry can be implemented in several ways. An entry can be implementedas, for instance, a record or a set of records within a data file. Anentry can also comprise a set of records within one or more data files.Similarly, an entry can be implemented as one or more tuples (a dataobject containing two or more components) within one or more relationaldatabase tables.

It should be appreciated that the service repository can be implementedas a database wherein the entries are implemented, for instance, usingrelational database tuples. Naturally, there could be several physicaldatabase records or tuples corresponding to one logical object or classentry.

The service repository can also be implemented as a file system, whereinthe said entries are implemented as, for instance, data files.

The service repository can also be internally distributed. The entriescan thus be stored in physically separate network nodes. For instance,the entries or groups could be addressed using internet URLs.

It should be appreciated that the said groups can be seen as a logicalgrouping for the said entries. The entries relating to the said groupsmay be stored as mixed in the said service repository.

The invention is now described in a context where services are stored tothe same place as the classes of the objects they are referencing. Thiskind of a system could be applied, for instance, in a Java basedIntelligent Network execution environment. The services and theirobjects are stored to a database in association with the executionenvironment. For each service, a serialized object instance is stored tothe database. Either beforehand or on demand a new object instance forthe service is deserialized. The deserialization on demand can occur,for instance, when the service is invoked by the subscriber. Thisinvocation is, for example, due to the receiving of a service triggeringmessage to the service execution environment.

In order to enforce version control in association with each serializedservice object, there is added a service version identifier field. Thedeserialization proceeds in the way that when the service object isdeserialized, a correct class loader is created using the serviceversion identifier. For instance, this means that the class loaderobject constructor method has the service version identifier asparameter. Now the class loader object instantiated has in itspossession the service version identifier. Another way to achieve thisis to fetch a class loader object from the database that corresponds tothe service version identifier.

The class loader having the correct service version identifier nowfetches from the database only the class versions that are known to workwith the service object having the service version identifier. Theclasses are stored into the database as well. The class names areassociated with class version identifiers. In other words, the classeshave in the database a primary key with two fields: class name and classversion identifier. Now the semantics of the class version identifiercan vary depending on the class selection policy. There can be severalclass selection policies. The objective of the policies is that theclass versions are loaded with which the service has been tested.

One policy is such that the classes must be as old as or older than theserialized service. In this policy the version identifiers can be equalto timestamps. Another policy is that there are cross-reference tables,which define for each service version identifier at least one classversion identifier for each class.

It can thus be seen that each class loader has its context. The contextcomprises the relationships between the allowed versions of services,classes and their helper classes. Thus, the context forms a hierarchy.

It should be appreciated that the said class loading means can be, forinstance, any means which can hide the class loading from theprogrammer. The class loader providing the said mapping means could alsobe implemented by a virtual machine or interpreter directly or by thecomputer operating system or its associated facility.

Java is quite a good environment to construct the invention. Theabove-mentioned initial class loader is a normal element in Java.Serializing is powerful way to use in handling of different versions.However, there is a basic difference between a traditional Javaapplication and an application according to the invention. As atraditional Java application, like in FIG. 6, includes a “root” class(SP) and several other classes (SC 1,SC 2,SC N), who refer to objects,an application according to the invention is based on an object thatincludes all state information of the service. The object is preferablyserialized, and it also includes references to classes belonging to theservice. The object also includes references for other objects needed inthe service. These other objects have to be serialized as well. In otherwords, an application according to the invention is constructedconversely than a traditional Java application.

FIG. 7 illustrates a flow chart, which describes an embodiment of themethod according to the invention. First, groups for the services andthe classes in the service repository are provided (41), the first groupcomprising entries of the service objects concerning applications, i.eservices and the second group comprising entries of the classes. Eachservice entry is formed (42) in a way that each entry includes a fieldfor the version information of the object and at least one object.Correspondingly, each class entry is formed (43) in a way that eachentry includes a field for the version information of the class. Meansfor mapping the objects with the classes are provided for realizing theapplications.

For executing the application desired the method have to perform certaintasks. A desired service entry of the application is searched (45) inthe first group. The service object of the service entry is loaded (46)from the first group from the service repository to the use of theserver. The means for mapping are used (47) to discover the classes, inthe second group. The classes of the class entries, associated with theservice object are loaded (48) to the server.

The invention makes it possible to handle multiple versions of servicesoftware. As software evolves, there will be several parallel versionsof the same service. A new class working with an old class may causeunexpected fails. Due to this services should be tested in a newenvironment where there exist class versions created at different times.However, testing is unfeasible on a large server environment whereseveral service applications use the same new component version. Therecan be hundreds of different services that should be tested forguaranteeing the function of the services. It can be noticed thataccording to the invention old service classes working together form anold service, and new classes working together form a new serviceversion. Mixing old and new classes for realizing a service do notexist. In other words, none of classes is newer-than-tested.

The invention has been created and described in Java programminglanguage, but that does not mean that this is the only solution. Thereexist several other object-oriented program environments also, wherebythe invention can be realized. Furthermore, it is clear that theinvention can be used in many ways in the scope of the inventive idea.

1. A method comprising: grouping different versions of serviceapplications and classes in at least one service repository into a firstgroup comprising entries of service objects and a second groupcomprising entries of classes, forming the entries of the serviceobjects in the first group to include a first information field forrepresenting information about a version of a service and at least oneservice object, forming the entries of the classes in the second groupto include a second information field for representing information abouta version of the class, and mapping the service objects with the classesto provision the service applications, wherein the different versions ofservice applications include different versions of a same serviceapplication, and wherein the different versions of classes includedifferent versions of a same class, wherein when executing a desiredservice application, the method further comprises searching for aservice entry of a desired service application from the first group,loading a service object of the service entry of the desired serviceapplication from the first group for use by at least one server, usingthe mapping to discover entries of the classes of the second groupassociated with said service object of the service entry of the desiredservice application, and loading the entries of the classes of thesecond group associated with said service object of the service entry ofthe desired service application to the server.
 2. A method according toclaim 1, wherein the mapping comprises comparing the version of thefirst information field of entries in the first group with the versionof the second information field of the entries in the second group.
 3. Amethod according to claim 1, wherein said loading of said serviceobjects is performed using deserialization of a serialized storageformat of the service objects.
 4. A method according to claim 1, whereinloading the entries of the classes associated with the said serviceobject is performed using a class loader.
 5. A method according to claim4, further comprising constructing at least one class loader based onthe information in the first information field.
 6. A method according toclaim 5, wherein the class loader uses the mapping for loading theclasses from the second group.
 7. A method according to claim 1, themethod further comprising using additional data when mapping serviceobjects with classes.
 8. A method according claim 1, the method furthercomprising using at least one database to provide the servicerepository.
 9. A method according claim 1, the method further comprisingproviding the service repository using at least one file system.
 10. Asystem comprising: at least one service repository; at least one server;a first group in the at least one service repository comprising entriesof service objects, wherein at least one of an entry of the serviceobjects comprises a first information field to represent informationabout a version of a service and at least one service object, a secondgroup in the at least one service repository comprising an entry of aclass, wherein at least one of an entry of a class comprises a secondinformation field to represent information about a version of a class,and a mapping unit configured to map the service objects with theclasses for provisioning of the service application, wherein differentversions of service applications include different versions of a sameservice application, and wherein different versions of classes includedifferent versions of a same class, wherein when executing a desiredservice application, the system is configured to: search for a serviceentry of a desired service application from the first group, load aservice object of the service entry of the desired service applicationfrom the first group for use by the at least one server, use the mappingto discover entries of the classes of the second group associated withsaid service object of the service entry of the desired serviceapplication, and load the entries of the classes of the second groupassociated with said service object of the service entry of the desiredservice application to the server.
 11. The system according to claim 10,wherein the at least one server contains a service loader configured toload the at least one service object from the at least one servicerepository.
 12. The system according to claim 11, further comprising aversion specific class loader formed after the service loader loads thedesired service objects of the service from the first group.
 13. Thesystem according to claim 12, wherein the version specific class loaderis configured to use the mapping unit to load the classes from thesecond group.
 14. The system according to claim 13, wherein the mappingunit is configured to use the version of the first information field ofentries in the first group.
 15. The system according to claim 11,further comprising a special predetermined class loader.
 16. The systemaccording to claim 15, wherein the special predetermined class loader isconfigured to use the mapping unit to load the classes from the secondgroup.
 17. The system according to claim 16, wherein the mapping unit isconfigured to use the version of the first information field of entriesin the first group.
 18. The system according to claim 10, wherein themapping unit is configured to use additional data when mapping theservice objects with the classes.
 19. The system according to claim 10,wherein the at least one service repository comprises at least onedatabase.
 20. The system according to claim 10, wherein the at least oneservice repository comprises at least one file system.
 21. A systemcomprising: at least one service repository; at least one server; afirst group means in the at least one service repository comprisingentries of service objects, wherein at least one of an entry of theservice objects comprises a first information field for representinginformation about a version of a service and at least one serviceobject; a second group means in the at least one service repositorycomprising an entry of a class, wherein at least one of an entry of aclass comprises a second information field for representing informationabout a version of a class, and mapping means for mapping the serviceobjects with the classes for provisioning of the service application,wherein different versions of service applications include differentversions of a same service application, and wherein different versionsof classes include different versions of a same class, wherein whenexecuting a desired service application, the system further comprisesmeans for searching for a service entry of a desired service applicationfrom the first group means, means for loading a service object of theservice entry of the desired service application from the first groupmeans for use by the at least one server, means for using the mapping todiscover entries of the classes of the second group associated with saidservice object of the service entry of the desired service application,and means for loading the entries of the classes of the second groupassociated with said service object of the service entry of the desiredservice application to the server.
 22. An apparatus comprising: at leastone server configured to: group different versions of serviceapplications and classes in at least one service repository into a firstgroup comprising entries of service objects and a second groupcomprising entries of classes, form the entries of the service objectsin the first group to include a first information field to representinformation about a version of a service and at least one serviceobject, form the entries of the classes in the second group to include asecond information field to represent information about a version of theclass, and map the service objects with the classes to provision theservice applications, wherein different versions of service applicationsinclude different versions of a same service application, and whereindifferent versions of classes include different versions of a sameclass, wherein when executing a desired service application, theapparatus is configured to: search for a service entry of a desiredservice application from the first group, load a service object of theservice entry of the desired service application from the first groupfor use by the at least one server, use the mapping to discover entriesof the classes of the second group associated with said service objectof the service entry of the desired service application, and load theentries of the classes of the second group associated with said serviceobject of the service entry of the desired service application to the atleast one server.
 23. The apparatus according to claim 22, wherein theapparatus is configured to compare the version of the first informationfield of entries in the first group with the version of the secondinformation field of the entries in the second group.
 24. The apparatusaccording to claim 22, wherein said loading of said service objects isperformed using deserialization of a serialized storage format of theservice objects.
 25. The apparatus according to claim 22, wherein saidloading of the entries of the classes associated with the said serviceobject is performed using a class loader.
 26. The apparatus according toclaim 22, wherein the apparatus is configured to construct at least oneclass loader based on the information in the first information field.27. The apparatus according to claim 26, wherein the class loader isconfigured to use the mapping to load the classes from the second group.28. The apparatus according to claim 22, wherein additional data is usedwhen mapping service objects with classes.
 29. The apparatus accordingto claim 22, wherein at least one database is used to provide theservice repository.
 30. The apparatus according to claim 22, wherein theservice repository is provided using at least one file system.
 31. Acomputer program, embodied on a computer-readable storage medium, thecomputer program configured to control a processor to perform a methodcomprising: grouping different versions of service applications andclasses in at least one service repository into a first group comprisingentries of service objects and a second group comprising entries ofclasses, forming the entries of the service objects in the first groupto include a first information field for representing information abouta version of a service and at least one service object, forming theentries of the classes in the second group to include a secondinformation field for representing information about a version of theclass, and mapping the service objects with the classes to provision theservice applications, wherein different versions of service applicationsinclude different versions of a same service application, and whereindifferent versions of classes include different versions of a sameclass, wherein when executing a desired service application, the methodfurther comprises: searching for a service entry of a desired serviceapplication from the first group, loading a service object of theservice entry of the desired service application from the first groupfor use by at least one server; using the mapping to discover entries ofthe classes of the second group associated with said service object ofthe service entry of the desired service application, and loading theentry of the classes of the second group associated with said serviceobject of the service entry of the desired service application to theserver.